

//
//  ZJ_MapKits
//
//  Created by PSVMC on 15/6/8.
//  Copyright (c) 2015年 PSVMC. All rights reserved.
//

import Foundation
import CoreLocation

final class KS_MapKits {
    private init() {}
    static let shared = KS_MapKits()
    //WGS-84：是国际标准，GPS坐标（Google Earth使用、或者GPS模块）
    //GCJ-02：中国坐标偏移标准，Google Map、高德、腾讯使用
    //BD-09： 百度坐标偏移标准，Baidu Map使用
    
    
    let  a = 6378245.0;
    let  ee = 0.00669342162296594323;
    let  pi = 3.14159265358979324;
    let  xPi = Double.pi  * 3000.0 / 180.0;
    
    //WGS-84 --> GCJ-02
    func transformFromWGSToGCJ(wgsLoc:CLLocationCoordinate2D)->CLLocationCoordinate2D
    {
        var adjustLoc=CLLocationCoordinate2D();
        if( isLocationOutOfChina(location: wgsLoc))
        {
            adjustLoc = wgsLoc;
        }
        else
        {
            var adjustLat = transformLatWithX(x: wgsLoc.longitude - 105.0 ,y:wgsLoc.latitude - 35.0);
            var adjustLon = transformLonWithX(x: wgsLoc.longitude - 105.0 ,y:wgsLoc.latitude - 35.0);
            var radLat = wgsLoc.latitude / 180.0 * pi;
            var magic = sin(radLat);
            magic = 1 - ee * magic * magic;
            var sqrtMagic = sqrt(magic);
            adjustLat = (adjustLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
            adjustLon = (adjustLon * 180.0) / (a / sqrtMagic * cos(radLat) * pi);
            adjustLoc.latitude = wgsLoc.latitude + adjustLat;
            adjustLoc.longitude = wgsLoc.longitude + adjustLon;
        }
        return adjustLoc;
    }
    
    func transformLatWithX(x:Double,y:Double)->Double
    {
        var lat = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y ;
        lat += 0.2 * sqrt(fabs(x));
        
        lat += (20.0 * sin(6.0 * x * pi)) * 2.0 / 3.0;
        lat += (20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0;
        lat += (20.0 * sin(y * pi)) * 2.0 / 3.0;
        lat += (40.0 * sin(y / 3.0 * pi)) * 2.0 / 3.0;
        lat += (160.0 * sin(y / 12.0 * pi)) * 2.0 / 3.0;
        lat += (320 * sin(y * pi / 30.0)) * 2.0 / 3.0;
        return lat;
    }
    
    func transformLonWithX(x:Double,y:Double)->Double
    {
        var lon = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y ;
        lon +=  0.1 * sqrt(fabs(x));
        lon += (20.0 * sin(6.0 * x * pi)) * 2.0 / 3.0;
        lon += (20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0;
        lon += (20.0 * sin(x * pi)) * 2.0 / 3.0;
        lon += (40.0 * sin(x / 3.0 * pi)) * 2.0 / 3.0;
        lon += (150.0 * sin(x / 12.0 * pi)) * 2.0 / 3.0;
        lon += (300.0 * sin(x / 30.0 * pi)) * 2.0 / 3.0;
        return lon;
    }
    
    
 
    //GCJ-02 --> WGS-84
    func transformFromGCJToWGS(p:CLLocationCoordinate2D) -> CLLocationCoordinate2D
    {
        var threshold = 0.00001;
        
        // The boundary
        var minLat = p.latitude - 0.5;
        var maxLat = p.latitude + 0.5;
        var minLng = p.longitude - 0.5;
        var maxLng = p.longitude + 0.5;
        
        var delta = 1.0;
        var maxIteration = 30;
        // Binary search
        while(true)
        {
            var leftBottom  = transformFromWGSToGCJ(wgsLoc: CLLocationCoordinate2D(latitude: minLat,longitude: minLng));
            var rightBottom = transformFromWGSToGCJ(wgsLoc: CLLocationCoordinate2D(latitude : minLat,longitude : maxLng));
            var leftUp      = transformFromWGSToGCJ(wgsLoc: CLLocationCoordinate2D(latitude : maxLat,longitude : minLng));
            var midPoint    = transformFromWGSToGCJ(wgsLoc: CLLocationCoordinate2D(latitude : ((minLat + maxLat) / 2),longitude : ((minLng + maxLng) / 2)));
            delta = fabs(midPoint.latitude - p.latitude) + fabs(midPoint.longitude - p.longitude);
            
            if(maxIteration <= 1 || delta <= threshold)
            {
                return CLLocationCoordinate2D(latitude: (minLat + maxLat) / 2, longitude: (minLng + maxLng) / 2);
                
            }
            
            if(isContains(point: p, p1: leftBottom, p2: midPoint))
            {
                maxLat = (minLat + maxLat) / 2;
                maxLng = (minLng + maxLng) / 2;
            }
            else if(isContains(point: p, p1: rightBottom, p2: midPoint))
            {
                maxLat = (minLat + maxLat) / 2;
                minLng = (minLng + maxLng) / 2;
            }
            else if(isContains(point: p, p1: leftUp, p2: midPoint))
            {
                minLat = (minLat + maxLat) / 2;
                maxLng = (minLng + maxLng) / 2;
            }
            else
            {
                minLat = (minLat + maxLat) / 2;
                minLng = (minLng + maxLng) / 2;
            }
        }
        
    }
    
  
     
    //判断点是否在p1和p2之间
    //point: 点
    //p1:    左上角
    //p2:    右下角
    func isContains(point:CLLocationCoordinate2D , p1:CLLocationCoordinate2D, p2:CLLocationCoordinate2D)->Bool
    {
        
        return (point.latitude >= min(p1.latitude, p2.latitude) && point.latitude <= max(p1.latitude, p2.latitude)) && (point.longitude >= min(p1.longitude,p2.longitude) && point.longitude <= max(p1.longitude, p2.longitude));
    }
    
    
    //是否在中国以外
    func isLocationOutOfChina(location:CLLocationCoordinate2D) -> Bool
    {
        if (location.longitude < 72.004 || location.longitude > 137.8347 || location.latitude < 0.8293 || location.latitude > 55.8271){
            return true;
        }else{
            return false;
        }
        
    }
    
    ///获取两点之间的距离
    static func distanceByPoint(lat1:Double,lat2 :Double,lng1 :Double,lng2:Double)->Double{
        var dd = M_PI/180;
        var x1=lat1*dd;
        var x2=lat2*dd;
        var y1=lng1*dd;
        var y2=lng2*dd;
        var R = 6371004;
        
        var temp = 2 - 2 * cos(x1) * cos(x2) * cos(y1-y2) - 2 * sin(x1) * sin(x2);
        
        var distance = Double(2) * Double(R) * asin(sqrt(temp)/2);
        
        //返回 m
        return   distance;
        
    }
    
    ///获取两点之间的距离
    static  func distanceByPoint(point1:CLLocationCoordinate2D,point2:CLLocationCoordinate2D)->Double{
        return distanceByPoint(lat1: point1.latitude, lat2: point2.latitude, lng1: point1.longitude, lng2: point2.longitude);
        
    }
}


import Foundation
import CoreLocation

class CoordinateTransform {
    
    // 定义一些常量
    private static let pi = Double.pi
    private static let a = 6378245.0  // 长半轴
    private static let ee = 0.00669342162296594323  // 扁率
    
    /// WGS-84 转 GCJ-02（火星坐标系）
    /// - Parameter wgsPoint: WGS-84坐标点
    /// - Returns: GCJ-02坐标点
    private static func wgs84ToGCJ02(_ wgsPoint: CLLocationCoordinate2D) -> CLLocationCoordinate2D {
        var gcjPoint = CLLocationCoordinate2D()
        
        // 判断是否在国内
        if !isInChina(lat: wgsPoint.latitude, lon: wgsPoint.longitude) {
            return wgsPoint
        }
        
        let (dLat, dLon) = transform(wgsPoint.latitude, wgsPoint.longitude)
        gcjPoint.latitude = wgsPoint.latitude + dLat
        gcjPoint.longitude = wgsPoint.longitude + dLon
        
        return gcjPoint
    }
    
    /// GCJ-02（火星坐标系）转 BD-09（百度坐标系）
    /// - Parameter gcjPoint: GCJ-02坐标点
    /// - Returns: BD-09坐标点
    private static func gcj02ToBD09(_ gcjPoint: CLLocationCoordinate2D) -> CLLocationCoordinate2D {
        let z = sqrt(gcjPoint.longitude * gcjPoint.longitude + gcjPoint.latitude * gcjPoint.latitude) + 0.00002 * sin(gcjPoint.latitude * pi)
        let theta = atan2(gcjPoint.latitude, gcjPoint.longitude) + 0.000003 * cos(gcjPoint.longitude * pi)
        
        var bdPoint = CLLocationCoordinate2D()
        bdPoint.longitude = z * cos(theta) + 0.0065
        bdPoint.latitude = z * sin(theta) + 0.006
        
        return bdPoint
    }
    
    /// WGS-84 直接转 BD-09
    /// - Parameter wgsPoint: WGS-84坐标点
    /// - Returns: BD-09坐标点
    static func wgs84ToBD09(_ wgsPoint: CLLocationCoordinate2D) -> CLLocationCoordinate2D {
        let gcjPoint = wgs84ToGCJ02(wgsPoint)
        return gcj02ToBD09(gcjPoint)
    }
    
    /// 批量转换多个坐标点
    /// - Parameter wgsPoints: WGS-84坐标点数组
    /// - Returns: BD-09坐标点数组
    static func wgs84ToBD09(_ wgsPoints: [CLLocationCoordinate2D]) -> [CLLocationCoordinate2D] {
        return wgsPoints.map { wgs84ToBD09($0) }
    }
    
    // MARK: - 私有方法
    
    /// 判断坐标是否在中国境内
    private static func isInChina(lat: Double, lon: Double) -> Bool {
        if lon < 72.004 || lon > 137.8347 {
            return false
        }
        if lat < 0.8293 || lat > 55.8271 {
            return false
        }
        return true
    }
    
    /// 坐标偏移转换
    private static func transform(_ lat: Double, _ lon: Double) -> (Double, Double) {
        var dLat = transformLat(lon - 105.0, lat - 35.0)
        var dLon = transformLon(lon - 105.0, lat - 35.0)
        
        let radLat = lat / 180.0 * pi
        var magic = sin(radLat)
        magic = 1 - ee * magic * magic
        let sqrtMagic = sqrt(magic)
        
        dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi)
        dLon = (dLon * 180.0) / (a / sqrtMagic * cos(radLat) * pi)
        
        return (dLat, dLon)
    }
    
    private static func transformLat(_ x: Double, _ y: Double) -> Double {
        var ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * sqrt(abs(x))
        ret += (20.0 * sin(6.0 * x * pi) + 20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0
        ret += (20.0 * sin(y * pi) + 40.0 * sin(y / 3.0 * pi)) * 2.0 / 3.0
        ret += (160.0 * sin(y / 12.0 * pi) + 320 * sin(y * pi / 30.0)) * 2.0 / 3.0
        return ret
    }
    
    private static func transformLon(_ x: Double, _ y: Double) -> Double {
        var ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * sqrt(abs(x))
        ret += (20.0 * sin(6.0 * x * pi) + 20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0
        ret += (20.0 * sin(x * pi) + 40.0 * sin(x / 3.0 * pi)) * 2.0 / 3.0
        ret += (150.0 * sin(x / 12.0 * pi) + 300.0 * sin(x / 30.0 * pi)) * 2.0 / 3.0
        return ret
    }
}

// 扩展 CLLocationCoordinate2D 使其更易用
extension CLLocationCoordinate2D: @retroactive Equatable {
    public static func == (lhs: CLLocationCoordinate2D, rhs: CLLocationCoordinate2D) -> Bool {
        return lhs.latitude == rhs.latitude && lhs.longitude == rhs.longitude
    }
    
    /// 方便的初始化方法
    init(latitude: Double, longitude: Double) {
        self.init()
        self.latitude = latitude
        self.longitude = longitude
    }
    
    /// 格式化输出
    var description: String {
        return String(format: "纬度: %.6f, 经度: %.6f", latitude, longitude)
    }
}
